{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Install Packages"
      ],
      "metadata": {
        "id": "zd4phQJEFqfP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install gym pandas yfinance stable-baselines3 shimmy\n"
      ],
      "metadata": {
        "id": "SRTU1IkY6HFG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Da1nyRbZYqR8"
      },
      "outputs": [],
      "source": [
        "!pip install yfinance\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Day Trading Via Reinforcement Learning\n",
        "In the provided code, we're creating a custom reinforcement learning environment for stock trading using Gym, a popular open-source library for developing and comparing reinforcement learning algorithms. Let's break down what the code is doing:\n",
        "\n",
        "1. We import the required libraries. gym and spaces from Gym are used to create the environment, numpy and pandas for numerical and data frame operations, yfinance to fetch stock market data, and PPO from stable_baselines3 to implement the Proximal Policy Optimization algorithm.\n",
        "2. We define a custom class StockTradingEnv which inherits from gym.Env. This class simulates a stock trading environment.\n",
        "3. In the __init__ method, we initialize the state variables, such as the initial balance, the number of shares held, and the dataframes for the stock data.\n",
        "4. The step method is where the agent takes an action. The action can be either to hold, buy, or sell the stock. The method also calculates the reward which is the change in the asset value after taking the action.\n",
        "5. The reset method is called at the start of each new episode, resetting the environment to its initial state.\n",
        "6. The _next_observation method generates the next state based on the current state of the environment.\n",
        "\n",
        "7. The DummyVecEnv class from stable_baselines3 is used to create a vectorized wrapper for the environment. This is useful for algorithms that require a vector of observations and actions.\n",
        "8. We initialize a Proximal Policy Optimization (PPO) model with the custom environment and train it for a specified number of timesteps.\n",
        "9. Finally, we save the trained model using the save method. This model can then be loaded later for further training, evaluation or deployment."
      ],
      "metadata": {
        "id": "FKwNNjQjFt6k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import gym\n",
        "from gym import spaces\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import yfinance as yf\n",
        "from stable_baselines3 import PPO\n",
        "from stable_baselines3.common.vec_env import DummyVecEnv\n",
        "\n",
        "class StockTradingEnv(gym.Env):\n",
        "    metadata = {'render.modes': ['human']}\n",
        "\n",
        "    def __init__(self, df, pct_df, max_steps=1000):\n",
        "        super(StockTradingEnv, self).__init__()\n",
        "\n",
        "        self.df = df\n",
        "        self.pct_df = pct_df\n",
        "        self.reward_range = (-np.inf, np.inf)\n",
        "        self.action_space = spaces.Box(low=np.array([0, 0]), high=np.array([3, 1]), dtype=np.float16)\n",
        "        self.observation_space = spaces.Box(low=-np.inf, high=np.inf, shape=(5, 5), dtype=np.float16)\n",
        "        self.initial_balance = 10000\n",
        "        self.balance = self.initial_balance\n",
        "        self.shares_held = 0\n",
        "        self.current_step = 6\n",
        "        self.max_steps=max_steps\n",
        "        self.train_cnt_epoch=len(self.df.loc[:, 'Close'].values) - 2-6\n",
        "\n",
        "\n",
        "    def step(self, action):\n",
        "      self.current_step += 1\n",
        "\n",
        "      action_type = action[0]\n",
        "      amount = action[1]\n",
        "\n",
        "      close_price = self.df.loc[self.current_step, 'Close']\n",
        "      next_day_close_price=self.df.loc[self.current_step+1, 'Close']\n",
        "      # print('current_step ', self.current_step)\n",
        "      # print('close_price ', close_price)\n",
        "      # print('next_day_close_price ', next_day_close_price)\n",
        "\n",
        "\n",
        "      shares_bought = 0\n",
        "      shares_sold = 0\n",
        "      asset_value_before_action = self.balance + self.shares_held * close_price\n",
        "\n",
        "      if action_type < 1:\n",
        "          # Hold\n",
        "          pass\n",
        "      elif action_type < 2:\n",
        "          # Buy\n",
        "          total_possible = int(self.balance / close_price)\n",
        "          shares_bought = int(total_possible * amount)\n",
        "          total_cost = shares_bought * close_price\n",
        "          self.balance -= total_cost\n",
        "          self.shares_held += shares_bought\n",
        "      elif action_type < 3:\n",
        "          # Sell\n",
        "          shares_sold = int(self.shares_held * amount)\n",
        "          self.balance += shares_sold * close_price\n",
        "          self.shares_held -= shares_sold\n",
        "\n",
        "      if self.current_step >= self.train_cnt_epoch:\n",
        "          self.current_step = 6\n",
        "\n",
        "      obs = self._next_observation()\n",
        "\n",
        "      asset_value_after_action = self.balance + self.shares_held * next_day_close_price\n",
        "      reward = asset_value_after_action - asset_value_before_action\n",
        "      done = self.current_step >= self.max_steps or self.balance <= 0\n",
        "\n",
        "      return obs, reward, done, {}\n",
        "\n",
        "\n",
        "    def reset(self):\n",
        "        self.balance = self.initial_balance\n",
        "        self.shares_held = 0\n",
        "        self.current_step = 6\n",
        "\n",
        "        return self._next_observation()\n",
        "\n",
        "    def _next_observation(self):\n",
        "        end_slice = self.current_step + 1\n",
        "        start_slice = end_slice-4\n",
        "        # in iloc the last index is not inclusive; thus we are doing end_slice+1.\n",
        "        obs = self.pct_df.iloc[start_slice:end_slice+1].values\n",
        "        # print(start_slice, ' ', end_slice)\n",
        "        # print(obs)\n",
        "        return obs\n",
        "\n",
        "    def render(self, mode='human'):\n",
        "        return self.df.loc[self.current_step, 'Open']\n",
        "\n",
        "    def close(self):\n",
        "        return\n",
        "\n",
        "df = yf.download('AAPL', start='2020-01-01', end='2023-01-01')\n",
        "df = df.sort_values('Date')\n",
        "df = df.drop(columns='Adj Close')\n",
        "df = df.reset_index(drop=True)\n",
        "pct_df = df.copy()\n",
        "\n",
        "for feature in ['Open', 'High', 'Low', 'Close', 'Volume']:\n",
        "    pct_df[feature] = pct_df[feature].pct_change()\n",
        "\n",
        "print(df.head(20))\n",
        "print(pct_df.head(20))\n",
        "env = DummyVecEnv([lambda: StockTradingEnv(df, pct_df)])\n",
        "\n",
        "model = PPO(\"MlpPolicy\", env, verbose=1)\n",
        "model.learn(total_timesteps=10000)\n",
        "\n",
        "model.save(\"ppo_stock\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fOc3k8gKDh3J",
        "outputId": "1f398f64-8fac-4fd5-f2c4-eb06501bcd68"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\r[*********************100%***********************]  1 of 1 completed\n",
            "         Open       High        Low      Close     Volume\n",
            "0   74.059998  75.150002  73.797501  75.087502  135480400\n",
            "1   74.287498  75.144997  74.125000  74.357498  146322800\n",
            "2   73.447502  74.989998  73.187500  74.949997  118387200\n",
            "3   74.959999  75.224998  74.370003  74.597504  108872000\n",
            "4   74.290001  76.110001  74.290001  75.797501  132079200\n",
            "5   76.809998  77.607498  76.550003  77.407501  170108400\n",
            "6   77.650002  78.167503  77.062500  77.582497  140644800\n",
            "7   77.910004  79.267502  77.787498  79.239998  121532000\n",
            "8   79.175003  79.392502  78.042503  78.169998  161954400\n",
            "9   77.962502  78.875000  77.387497  77.834999  121923600\n",
            "10  78.397499  78.925003  78.022499  78.809998  108829200\n",
            "11  79.067497  79.684998  78.750000  79.682503  137816400\n",
            "12  79.297501  79.754997  79.000000  79.142502  110843200\n",
            "13  79.644997  79.997498  79.327499  79.425003  101832400\n",
            "14  79.480003  79.889999  78.912498  79.807503  104472000\n",
            "15  80.062500  80.832497  79.379997  79.577499  146537600\n",
            "16  77.514999  77.942497  76.220001  77.237503  161940000\n",
            "17  78.150002  79.599998  78.047501  79.422501  162234000\n",
            "18  81.112503  81.962502  80.345001  81.084999  216229200\n",
            "19  80.135002  81.022499  79.687500  80.967499  126743200\n",
            "        Open      High       Low     Close    Volume\n",
            "0        NaN       NaN       NaN       NaN       NaN\n",
            "1   0.003072 -0.000067  0.004438 -0.009722  0.080029\n",
            "2  -0.011307 -0.002063 -0.012648  0.007968 -0.190918\n",
            "3   0.020593  0.003134  0.016157 -0.004703 -0.080374\n",
            "4  -0.008938  0.011765 -0.001076  0.016086  0.213160\n",
            "5   0.033921  0.019675  0.030421  0.021241  0.287927\n",
            "6   0.010936  0.007216  0.006695  0.002261 -0.173205\n",
            "7   0.003348  0.014072  0.009408  0.021364 -0.135894\n",
            "8   0.016237  0.001577  0.003278 -0.013503  0.332607\n",
            "9  -0.015314 -0.006518 -0.008393 -0.004286 -0.247173\n",
            "10  0.005580  0.000634  0.008205  0.012526 -0.107398\n",
            "11  0.008546  0.009629  0.009324  0.011071  0.266355\n",
            "12  0.002909  0.000878  0.003175 -0.006777 -0.195718\n",
            "13  0.004382  0.003041  0.004146  0.003570 -0.081293\n",
            "14 -0.002072 -0.001344 -0.005231  0.004816  0.025921\n",
            "15  0.007329  0.011797  0.005924 -0.002882  0.402650\n",
            "16 -0.031819 -0.035753 -0.039808 -0.029405  0.105109\n",
            "17  0.008192  0.021266  0.023977  0.028289  0.001815\n",
            "18  0.037908  0.029680  0.029437  0.020932  0.332823\n",
            "19 -0.012051 -0.011469 -0.008183 -0.001449 -0.413848\n",
            "Using cpu device\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/gym/spaces/box.py:128: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float16\u001b[0m\n",
            "  logger.warn(f\"Box bound precision lowered by casting to {self.dtype}\")\n",
            "/usr/local/lib/python3.10/dist-packages/stable_baselines3/common/vec_env/patch_gym.py:49: UserWarning: You provided an OpenAI Gym environment. We strongly recommend transitioning to Gymnasium environments. Stable-Baselines3 is automatically wrapping your environments in a compatibility layer, which could potentially cause issues.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-----------------------------\n",
            "| time/              |      |\n",
            "|    fps             | 920  |\n",
            "|    iterations      | 1    |\n",
            "|    time_elapsed    | 2    |\n",
            "|    total_timesteps | 2048 |\n",
            "-----------------------------\n",
            "------------------------------------------\n",
            "| time/                   |              |\n",
            "|    fps                  | 531          |\n",
            "|    iterations           | 2            |\n",
            "|    time_elapsed         | 7            |\n",
            "|    total_timesteps      | 4096         |\n",
            "| train/                  |              |\n",
            "|    approx_kl            | 0.0020289088 |\n",
            "|    clip_fraction        | 0.00596      |\n",
            "|    clip_range           | 0.2          |\n",
            "|    entropy_loss         | -2.83        |\n",
            "|    explained_variance   | 2.8e-06      |\n",
            "|    learning_rate        | 0.0003       |\n",
            "|    loss                 | 2.27e+05     |\n",
            "|    n_updates            | 10           |\n",
            "|    policy_gradient_loss | -0.00234     |\n",
            "|    std                  | 0.997        |\n",
            "|    value_loss           | 4.35e+05     |\n",
            "------------------------------------------\n",
            "------------------------------------------\n",
            "| time/                   |              |\n",
            "|    fps                  | 542          |\n",
            "|    iterations           | 3            |\n",
            "|    time_elapsed         | 11           |\n",
            "|    total_timesteps      | 6144         |\n",
            "| train/                  |              |\n",
            "|    approx_kl            | 0.0010921274 |\n",
            "|    clip_fraction        | 0.00132      |\n",
            "|    clip_range           | 0.2          |\n",
            "|    entropy_loss         | -2.84        |\n",
            "|    explained_variance   | 0.000139     |\n",
            "|    learning_rate        | 0.0003       |\n",
            "|    loss                 | 1.16e+05     |\n",
            "|    n_updates            | 20           |\n",
            "|    policy_gradient_loss | -0.00137     |\n",
            "|    std                  | 1.01         |\n",
            "|    value_loss           | 2.18e+05     |\n",
            "------------------------------------------\n",
            "-----------------------------------------\n",
            "| time/                   |             |\n",
            "|    fps                  | 551         |\n",
            "|    iterations           | 4           |\n",
            "|    time_elapsed         | 14          |\n",
            "|    total_timesteps      | 8192        |\n",
            "| train/                  |             |\n",
            "|    approx_kl            | 0.004064158 |\n",
            "|    clip_fraction        | 0.0145      |\n",
            "|    clip_range           | 0.2         |\n",
            "|    entropy_loss         | -2.86       |\n",
            "|    explained_variance   | 0.00023     |\n",
            "|    learning_rate        | 0.0003      |\n",
            "|    loss                 | 6.48e+04    |\n",
            "|    n_updates            | 30          |\n",
            "|    policy_gradient_loss | -0.00461    |\n",
            "|    std                  | 1.01        |\n",
            "|    value_loss           | 1.68e+05    |\n",
            "-----------------------------------------\n",
            "------------------------------------------\n",
            "| time/                   |              |\n",
            "|    fps                  | 538          |\n",
            "|    iterations           | 5            |\n",
            "|    time_elapsed         | 19           |\n",
            "|    total_timesteps      | 10240        |\n",
            "| train/                  |              |\n",
            "|    approx_kl            | 0.0013506354 |\n",
            "|    clip_fraction        | 0.00161      |\n",
            "|    clip_range           | 0.2          |\n",
            "|    entropy_loss         | -2.86        |\n",
            "|    explained_variance   | 0.000177     |\n",
            "|    learning_rate        | 0.0003       |\n",
            "|    loss                 | 7.57e+04     |\n",
            "|    n_updates            | 40           |\n",
            "|    policy_gradient_loss | -0.000941    |\n",
            "|    std                  | 1.01         |\n",
            "|    value_loss           | 1.34e+05     |\n",
            "------------------------------------------\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Declaring Environment for Inference\n",
        "Creating a separate environment for inference (or testing) is a common practice in reinforcement learning for a few reasons:\n",
        "1. Different End Conditions: You might notice that the end condition (the done variable) in the test environment is different from the training environment. In the training environment, an episode might end when the balance drops to zero. However, in the test environment, we might want to run the episode for a fixed number of steps, regardless of the balance. This allows us to fully evaluate the model's performance over a complete episode.\n",
        "2. In the provided StockTradingTestEnv, it inherits from StockTradingEnv but overrides the step method to provide a different end condition and potentially other differences suitable for inference/testing. The method of creating a separate environment for testing ensures that the model is evaluated in a way that's independent of its training, giving a more reliable assessment of its ability to handle new data or scenarios."
      ],
      "metadata": {
        "id": "9VvDO1wtG5Pl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class StockTradingTestEnv(StockTradingEnv):\n",
        "    def __init__(self, df, pct_df, initial_balance=10000):\n",
        "        super().__init__(df, pct_df)\n",
        "        self.initial_balance = initial_balance\n",
        "        self.balance = self.initial_balance\n",
        "        self.train_cnt_epoch=len(self.df.loc[:, 'Close'].values) - 2-6\n",
        "\n",
        "    def step(self, action):\n",
        "        self.current_step += 1\n",
        "        action_type = action[0]\n",
        "        amount = action[1]\n",
        "\n",
        "        close_price = self.df.loc[self.current_step, 'Close']\n",
        "        next_day_close_price=self.df.loc[self.current_step+1, 'Close']\n",
        "\n",
        "        shares_bought = 0\n",
        "        shares_sold = 0\n",
        "        asset_value_before_action = self.balance + self.shares_held * close_price\n",
        "\n",
        "        if action_type < 1:\n",
        "            # Hold\n",
        "            pass\n",
        "        elif action_type < 2:\n",
        "            # Buy\n",
        "            total_possible = int(self.balance / close_price)\n",
        "            shares_bought = int(total_possible * amount)\n",
        "            total_cost = shares_bought * close_price\n",
        "            self.balance -= total_cost\n",
        "            self.shares_held += shares_bought\n",
        "        elif action_type < 3:\n",
        "            # Sell\n",
        "            shares_sold = int(self.shares_held * amount)\n",
        "            self.balance += shares_sold * close_price\n",
        "            self.shares_held -= shares_sold\n",
        "\n",
        "        if self.current_step >= len(self.df.loc[:, 'Close'].values) - 6:\n",
        "            self.current_step = 6\n",
        "\n",
        "        obs = self._next_observation()\n",
        "\n",
        "        asset_value_after_action = self.balance + self.shares_held * next_day_close_price\n",
        "        reward = asset_value_after_action - asset_value_before_action\n",
        "\n",
        "\n",
        "        if self.current_step >= self.train_cnt_epoch:\n",
        "          done = True\n",
        "        else:\n",
        "          done = False\n",
        "\n",
        "        return obs, reward, done, {}\n"
      ],
      "metadata": {
        "id": "3d9bFHZq42l-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Inference\n",
        "This code block is performing inference or testing on a trained PPO model for stock trading. Here's what the code is doing:\n",
        "1. Loading the Trained Model\n",
        "2. Downloading and Preprocessing New Dataset\n",
        "3.Setting Up Testing Environment: A new testing environment, StockTradingTestEnv, is initialized with the new data and final balance from training. The environment is wrapped with DummyVecEnv which is a simple vectorized wrapper for multiple environments, this makes it compatible with Stable Baselines' models.\n",
        "4. Running the Model: An initial state of the environment is set and the environment is run until it reaches the end. In each step, the model predicts the next action based on the current state. This action is then passed to the environment through the step function which returns the new state, reward, whether the episode is done, and other info. If the episode is not done, the current portfolio value (the balance plus the current value of held shares) is calculated and stored in the portfolio_values list. This continues until all the new data is used.\n",
        "5. Plotting Portfolio Value: Finally, a plot is created to show how the value of the portfolio changes over time. The x-axis is the step number and the y-axis is the portfolio value.\n"
      ],
      "metadata": {
        "id": "hLtoG9vVHSuf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from stable_baselines3 import PPO\n",
        "\n",
        "# Load the saved model\n",
        "model = PPO.load(\"ppo_stock.zip\")\n",
        "\n",
        "# Load the new dataset\n",
        "df_2023 = yf.download('AAPL', start='2023-01-01', end='2023-05-30')\n",
        "df_2023 = df_2023.sort_values('Date')\n",
        "df_2023 = df_2023.drop(columns='Adj Close')\n",
        "df_2023 = df_2023.reset_index(drop=True)\n",
        "\n",
        "# Create a new percentage change dataframe\n",
        "pct_df_2023 = df_2023.copy()\n",
        "\n",
        "for feature in ['Open', 'High', 'Low', 'Close', 'Volume']:\n",
        "    pct_df_2023[feature] = pct_df_2023[feature].pct_change()\n",
        "\n",
        "# Adjust the environment to use the new data and the final balance from the training\n",
        "final_training_balance = 100000\n",
        "env = DummyVecEnv([lambda: StockTradingTestEnv(df_2023, pct_df_2023, initial_balance=final_training_balance)])\n",
        "\n",
        "# Set the initial state of the environment\n",
        "initial_state = env.reset()\n",
        "done = False\n",
        "\n",
        "# This list will hold the value of the portfolio at each step\n",
        "portfolio_values = []\n",
        "\n",
        "while not done:\n",
        "    # Get the action from the model\n",
        "    action, _ = model.predict(initial_state)\n",
        "    # print('printing action')\n",
        "    # print(action)\n",
        "\n",
        "    # Take a step in the environment and get the new state and reward\n",
        "    initial_state, reward, done, info = env.step(action)\n",
        "    # The current value of the portfolio is the initial balance plus the value of the shares held\n",
        "\n",
        "    if not done:\n",
        "        portfolio_value = env.envs[0].balance + (env.envs[0].shares_held * env.envs[0].df.loc[env.envs[0].current_step, 'Close'])\n",
        "        # print('balance', env.envs[0].balance)\n",
        "        # print('shares_held', env.envs[0].shares_held)\n",
        "        # print('portfolio_value', portfolio_value)\n",
        "        # # Add the portfolio value to the list\n",
        "        portfolio_values.append(portfolio_value)\n",
        "        # print('portfolio_values', portfolio_values)\n",
        "        # print('current_step', env.envs[0].current_step)\n",
        "    else:\n",
        "        print(\"Reached the end of the data.\")\n",
        "\n",
        "\n",
        "# Plot the portfolio value over time\n",
        "plt.figure(figsize=(10,6))\n",
        "plt.plot(portfolio_values)\n",
        "plt.title('Portfolio Value Over Time')\n",
        "plt.xlabel('Step')\n",
        "plt.ylabel('Value')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 686
        },
        "id": "ieZF8SJ3yUyD",
        "outputId": "082f3f15-89f2-4776-bf49-eb2e97f24e24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\r[*********************100%***********************]  1 of 1 completed\n",
            "Reached the end of the data.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/gym/spaces/box.py:128: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float16\u001b[0m\n",
            "  logger.warn(f\"Box bound precision lowered by casting to {self.dtype}\")\n",
            "/usr/local/lib/python3.10/dist-packages/stable_baselines3/common/vec_env/patch_gym.py:49: UserWarning: You provided an OpenAI Gym environment. We strongly recommend transitioning to Gymnasium environments. Stable-Baselines3 is automatically wrapping your environments in a compatibility layer, which could potentially cause issues.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Let's Check if the model still works for another type of stock"
      ],
      "metadata": {
        "id": "vjfwJw_uH7FP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from stable_baselines3 import PPO\n",
        "\n",
        "# Load the saved model\n",
        "model = PPO.load(\"ppo_stock.zip\")\n",
        "\n",
        "# Load the new dataset\n",
        "df_2023 = yf.download('WMT', start='2023-01-01', end='2023-05-30')\n",
        "df_2023 = df_2023.sort_values('Date')\n",
        "df_2023 = df_2023.drop(columns='Adj Close')\n",
        "df_2023 = df_2023.reset_index(drop=True)\n",
        "\n",
        "# Create a new percentage change dataframe\n",
        "pct_df_2023 = df_2023.copy()\n",
        "\n",
        "for feature in ['Open', 'High', 'Low', 'Close', 'Volume']:\n",
        "    pct_df_2023[feature] = pct_df_2023[feature].pct_change()\n",
        "\n",
        "# Adjust the environment to use the new data and the final balance from the training\n",
        "final_training_balance = 100000\n",
        "env = DummyVecEnv([lambda: StockTradingTestEnv(df_2023, pct_df_2023, initial_balance=final_training_balance)])\n",
        "\n",
        "# Set the initial state of the environment\n",
        "initial_state = env.reset()\n",
        "done = False\n",
        "\n",
        "# This list will hold the value of the portfolio at each step\n",
        "portfolio_values = []\n",
        "\n",
        "while not done:\n",
        "    # Get the action from the model\n",
        "    action, _ = model.predict(initial_state)\n",
        "    # print('printing action')\n",
        "    # print(action)\n",
        "\n",
        "    # Take a step in the environment and get the new state and reward\n",
        "    initial_state, reward, done, info = env.step(action)\n",
        "    # The current value of the portfolio is the initial balance plus the value of the shares held\n",
        "\n",
        "    if not done:\n",
        "        portfolio_value = env.envs[0].balance + (env.envs[0].shares_held * env.envs[0].df.loc[env.envs[0].current_step, 'Close'])\n",
        "        # print('balance', env.envs[0].balance)\n",
        "        # print('shares_held', env.envs[0].shares_held)\n",
        "        # print('portfolio_value', portfolio_value)\n",
        "        # # Add the portfolio value to the list\n",
        "        portfolio_values.append(portfolio_value)\n",
        "        # print('portfolio_values', portfolio_values)\n",
        "        # print('current_step', env.envs[0].current_step)\n",
        "    else:\n",
        "        print(\"Reached the end of the data.\")\n",
        "\n",
        "\n",
        "# Plot the portfolio value over time\n",
        "plt.figure(figsize=(10,6))\n",
        "plt.plot(portfolio_values)\n",
        "plt.title('Portfolio Value Over Time')\n",
        "plt.xlabel('Step')\n",
        "plt.ylabel('Value')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 686
        },
        "id": "3tAGPOUJ2v3a",
        "outputId": "fb0ef382-974e-4e00-a06f-53e738f29782"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\r[*********************100%***********************]  1 of 1 completed\n",
            "Reached the end of the data.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/gym/spaces/box.py:128: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float16\u001b[0m\n",
            "  logger.warn(f\"Box bound precision lowered by casting to {self.dtype}\")\n",
            "/usr/local/lib/python3.10/dist-packages/stable_baselines3/common/vec_env/patch_gym.py:49: UserWarning: You provided an OpenAI Gym environment. We strongly recommend transitioning to Gymnasium environments. Stable-Baselines3 is automatically wrapping your environments in a compatibility layer, which could potentially cause issues.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "BL8y6bk1cKQE"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}